<script type="text/javascript">
	function Person(){}
	console.log(Person.prototype);//看原型里有啥，原型就是对象，发现对象也有一个属性是__proto__,__proto__是指向原型，说明原型里还有原型
</script>

<script>
	
    Grand.prototype.Lastname = 'a';
    function Grand(){}

    //通过构造函数Grand构造出一个grand,grand是Father构造函数的一个原型
    var grand = new Grand();

    Father.prototype = grand;
    function Father(){
    	this.name = 'bn'

    }

    var father = new Father();

    Son.prototype = father;
    function Son (){
    	this.hobby = 'smoke'
    }

    var son = new Son();

    console.log(son.hobby);
    console.log(son.name);//找自身的__proto__为Son.prototype,为father有name属性
    console.log(son.Lastname);//找Son的__proto__,father没有name属性，接着找father的__proto__为Father.prototype,找到grand的__proto__,找到Grand.prototype的Lastname为'a'
    //在原型上增加一个原型，再加一个原型，这样一个方法，把原型连成链，访问顺序按照链的顺序，像作用域链一样的一个东西，叫做原型链，连接点就是__proto__.近的有就访问，没有就访问远的

    console.log(son.toString);//找到Grand是已知能看到的头
    console.log(Grand.prototype);//原型是一个对象，上面也有__proto__属性
    // Grand.prototype.__proto__ --->指向 Object.prototype;
 //    console.log(Object.prototype.__proto__);//原型链的终端,Object.protype是所有对象的最终原型，里面没有__proto__了
 	console.log(Object.prototype.__proto__);
 	console.log(Object.prototype);
</script>

//原型链上的增删改查，和原型上的增删改查基本上一致
查看 ： 近的没有往远的查，一直找到原型链的终端，终端没有就是undefined
<script type="text/javascript">
	function Father(){
		this.name = 'kl'
		this.fortune = {
			card1 : 'visa'
		}
	}
	var father = new Father();

	Son.prototype = father;
	function Son(){
		this.hobbit = 'smoke';
	}
	var son = new Son();

	delete Father.prototype.name;//删，通过自己删
	//delete son.prototype.name;//通过子孙不能删

	console.log(son.fortune);

	son.fortune = 200;
	console.log(son);
	console.log(father.fortune);//修改son的fortune属性，father没变

	delete son.fortune;
	son.fortune.card2 = 'gh';//son.fortune引用fortune属性，增加值，引用值自己的修改，引用值加东西，相当于给fortune加属性；不是赋值的修改，是调用的修改；仅限于引用之，原始值不行，原始值只能覆盖
	console.log(son.fortune);
	console.log(father);//通过后代的引用给fortune增加了值
	</script>

<script type="text/javascript">
	function Father(){
		this.num = 1;
	}

	var father = new Father();

	Son.prototype = father;
	function Son(){}
	var son = new Son();

	console.log(son.num);
	console.log(son.num ++);
	console.log(son.num);//son.sum =son.sum + 1;把father.num取过来再赋给自身，father.num没变 
	console.log(father.num);
	
</script>



<script type="text/javascript">
	//sayName里面的this指向是，谁调用这个方法，this就是指向谁
	Person.prototype = {
		name : 'a',
		sayName : function (){
			console.log(this.name);
		}
	}
	function Person(){
		this.name = 'b';
	}
	var person = new Person();

	console.log(person.sayName());
	console.log(Person.prototype.sayName());
</script>

<script type="text/javascript">
	Person.prototype = {
		height : 100//不会变化
	}

	function Person(){
		this.eat = function (){
			this.height ++;
		}
	}

	var person = new Person();
	console.log(person);
	console.log(person.__proto__)

</script>

